Apparatus and methods for time-multiplex field-programmable gate arrays with multiple clocks

ABSTRACT

A multiple-clock time-multiplexed field programmable gate array (TM-FPGA) includes programmable logic circuitry. A plurality of clock signals within the TM-FPGA couple to the programmable logic circuitry. A user&#39;s circuit can be mapped to the programmable logic circuitry without the user&#39;s intervention in mapping the circuit to the programmable logic circuitry.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation-in-part application of, and incorporates by reference, U.S. patent application Ser. No. 10/941,369, titled “Apparatus and Methods for Time-Multiplexed Field-Programmable Gate Arrays,” filed on Sep. 15, 2004 now abandoned.

TECHNICAL FIELD

The inventive concepts relate generally to programmable or configurable circuitry and, more particularly, to apparatus and methods for multiple-clock time-multiplexed (TM) field-programmable gate arrays (FPGAs), or TM-FPGAs, and related design flows and computer-aided design (CAD) methodology.

BACKGROUND

FPGAs allow circuit designers to prototype relatively complex designs before finalizing the design as well as in production of end-products. Compared to application specific integrated circuits (ASICs), FPGAs provide designers the flexibility of revising or refining their designs in their laboratories without having a full-blown fabrication of each iteration or revision to the design. Because of their flexibility and programmability, however, typical FPGAs may not contain enough hardware resources to implement or emulate relatively complex designs.

TM-FPGAs seek to re-use the FPGA's hardware. Thus, they provide the designer with apparent increased hardware resources (in exchange for slower operating speed). As a result, designers may implement larger designs than ordinary FPGAs would allow. To use conventional TM-FPGAs advantageously, however, designers should have knowledge of the time-multiplexed nature of the FPGA. Thus, the user has involvement in the process of implementing the design in the TM-FPGAs and often has to make decisions about various aspects of that process. A need exists for multiple-clock TM-FPGAs that allow implementation of a user's design without the user's extensive involvement in that process.

SUMMARY

The inventive concepts contemplate novel multiple-clock TM-FPGAs. One aspect of the invention relates to multiple-clock TM-FPGA apparatus. In one illustrative embodiment, a TM-FPGA includes a plurality of clock signals coupled to programmable logic circuitry used to implement a user's design. The user's circuit can be mapped to the programmable logic circuitry without the user's intervention in mapping the circuit to the programmable logic circuitry. In a second illustrative embodiment, the programmable logic circuitry of the TM-FPGA is clocked by a plurality of clock signals, and the user's circuit is automatically mapped to the programmable logic circuitry.

Another aspect of the invention relates to methods of designing, using, and operating TM-FPGAs. In one illustrative embodiment, a method of implementing an electronic circuit using a TM-FPGA includes obtaining a design of the electronic circuit design from a user, and mapping the electronic circuit to resources within the TM-FPGA without the user's intervention. The method further includes programming the TM-FPGA so as to implement the electronic circuit.

BRIEF DESCRIPTION OF THE DRAWINGS

The appended drawings illustrate only exemplary embodiments of the invention and therefore should not be considered as limiting its scope. Persons of ordinary skill in the art who have the benefit of the description of the invention appreciate that the disclosed inventive concepts lend themselves to other equally effective embodiments. In the drawings, the same numeral designators used in more than one drawing denote the same, similar, or equivalent functionality, components, or blocks.

FIG. 1 shows a general block diagram of a TM-FPGA according to an illustrative embodiment of the invention.

FIG. 2 illustrates various software modules that TM-FPGA CAD software according to illustrative embodiments of the invention uses.

FIG. 3 depicts a general block diagram representation of a user's circuit for implementation in a TM-FPGA according to the invention.

FIG. 4 shows an ideally partitioned circuit, partitioned by CAD software according to the invention.

FIG. 5 illustrates a typical partitioning of a user's circuit for implementation in a TM-FPGA according to the invention.

FIG. 6 depicts an example of a user's circuit with context registers or storage elements added to facilitate partitioning of the circuit by the CAD software.

FIG. 7 shows a simplified flow diagram of a process that CAD software according to exemplary embodiments of the invention performs to map a user's circuit to a TM-FPGA's resources.

FIG. 8 illustrates an example of a simple circuit for implementation in a TM-FPGA.

FIG. 9 depicts the circuit of FIG. 8 partitioned by the CAD software into clusters.

FIG. 10 shows the circuit of FIG. 9, as further processed by the CAD software.

FIG. 11 illustrates the circuit of FIG. 10, as further processed by the CAD software.

FIG. 12 depicts an illustrative embodiment of a three-context TM-FPGA used to implement the simple circuit shown in FIG. 11.

FIG. 13 shows the functionality realized by the various resources within the TM-FPGA during the first context of the TM-FPGA in FIG. 12.

FIG. 14 illustrates shows the functionality realized by the various resources within the TM-FPGA during the second context of the TM-FPGA in FIG. 12.

FIG. 15 depicts shows the functionality realized by the various resources within the TM-FPGA during the third context of the TM-FPGA in FIG. 12.

FIG. 16 shows a block diagram of a configurable or programmable logic circuit used in TM-FPGAs according to exemplary embodiments of the invention.

FIG. 17 illustrates a multiple-clock TM-FPGA according to an illustrative embodiment of the invention.

FIG. 18 depicts an example of related multiple clock signals in a TM-FPGA according to an exemplary embodiment of the invention.

FIG. 19 shows an example of two clock signals where the frequency of one clock signal does not constitute a multiple of the frequency of the other clock signal.

FIG. 20 illustrates an example of two clock signals 1015A and 1018A where the frequency of one clock signal constitutes a multiple of the frequency of the other clock signal.

FIG. 21 depicts a circuit arrangement in which TM-FPGA according to an illustrative embodiment of the invention delivers data to an external destination.

FIG. 22 shows a circuit arrangement for providing multiple clock signals in TM-FPGA according to an exemplary embodiment of the invention.

FIG. 23 illustrates another circuit arrangement for providing multiple clock signals in TM-FPGA according to an exemplary embodiment of the invention.

FIG. 24 depicts yet another circuit arrangement for providing multiple clock signals in TM-FPGA according to an exemplary embodiment of the invention.

DETAILED DESCRIPTION

The inventive concepts contemplate apparatus and associated methods for novel TM-FPGAs and related design flows and CAD methodology. With the disclosed novel TM-FPGAs, other than the clocking arrangement, the user need not target his or her design specifically for a TM-FPGA.

The disclosed TM-FPGAs provide many advantages over previously proposed TM-FPGAs. First, they are suitable for general-purpose applications, rather than niche applications that use re-configurable computing. Second, with the disclosed TM-FPGAs, design flow, and CAD methodology, the user does not have to intervene in the design process as is the case with conventional TM-FPGAs. This property of the disclosed TM-FPGAs makes them suitable for mainstream use and applications by typical users, rather than users that have specialized knowledge.

Third, TM-FPGAs according to the invention provide more efficient solutions. More specifically, they can provide die area savings (typically, a factor of two or more) over conventional FPGAs. Fourth, one may use the disclosed TM-FPGAs for prototyping structured ASICs. As long as one matches input/output (I/O) connections between the two approaches, one may use the time-multiplexed nature of the TM-FPGAs to prototype structured ASICs. The time-multiplexed nature of the TM-FPGA allows prototyping a relatively large structured ASIC product.

Fifth, because the user need not know about the time-multiplexed nature of the FPGA, the user may use the TM-FPGA more easily to implement his or her designs. Sixth, the disclosed novel TM-FPGAs overcome the glitch restrictions associated with conventional TM-FPGAs. Other benefits and advantages of the novel TM-FPGAs become apparent in to persons of ordinary skill in the art in the rest of the description.

FIG. 1 shows a general block diagram of a TM-FPGA 103 according to an illustrative embodiment of the invention. TM-FPGA 103 includes configuration circuitry 130, configuration memory 133 (also known as configuration random-access memory, or CRAM), control circuitry 136, programmable logic 106, and programmable interconnect 109. In addition, TM-FPGA 103 may include one or more processors 118, one or more communication circuitry 121, one or more memories 124, one or more controllers 127, as desired. The user may implement a design using the various resources of the TM-FPGA, such as programmable logic 106, programmable interconnect 109, etc.

Note that FIG. 1 shows a simplified block diagram of TM-FPGA 103. Thus, TM-FPGA 103 may include other blocks and circuitry, as persons of ordinary skill in the art understand. Examples of such circuitry include clock generation and distribution circuits, redundancy circuits, test/debug circuits, and the like. Furthermore, TM-FPGA 103 may include, analog circuitry, other digital circuitry, and/or mixed-mode circuitry, as desired.

Programmable logic 106 includes blocks of configurable or programmable logic circuitry, such as look-up tables (LUTs), product-term logic, multiplexers, logic gates, registers, memory, and the like. Persons of ordinary skill in the art may recognize the blocks of configurable or programmable logic by various names, such as logic elements (LEs), logic cells (LCs), macro-cells (MCs or MCells), adaptive logic modules (ALMs) and adaptive look-up tables (ALUTs), etc. Compared to conventional circuits, the configurable or programmable logic blocks include additional circuitry to provide the time-multiplexed feature of the disclosed TM-FPGAs, as described below in detail.

Programmable interconnect 109 couples to programmable logic 106. Programmable interconnect 109 provides configurable interconnects (coupling mechanisms) between various blocks within programmable logic 106 and other circuitry within or outside TM-FPGA 103.

Configuration memory 133 stores configuration data for TM-FPGA 103. Configuration memory 133 may obtain the configuration data from an external source, such as a storage device, a host, etc. Control circuitry 136 controls various operations within TM-FPGA 103. Under the supervision of control circuitry 136, TM-FPGA configuration circuitry 130 uses configuration data from configuration memory 133 to program or configure the functionality of TM-FPGA 103. The configuration data determine the functionality of TM-FPGA 103 by programming the configurable resources of TM-FPGA 103, such as programmable logic 106 and programmable interconnect 109, as persons skilled in the art with the benefit of the description of the invention understand.

As noted above, TM-FPGA 103 may include one or more processors 118. Processor 118 may couple to other blocks and circuits within TM-FPGA 103. Processor 118 may receive data and information from circuits within or external to TM-FPGA 103 and process the information in a wide variety of ways, as persons skilled in the art with the benefit of the description of the invention appreciate. One or more of processor(s) 118 may constitute a digital signal processor (DSP). DSPs allow performing a wide variety of signal processing tasks, such as compression, decompression, audio processing, video processing, filtering, and the like, as desired.

TM-FPGA 103 may also include one or more communication circuitry 121. Communication circuitry 121 may facilitate data and information exchange between various circuits within TM-FPGA 103 and circuits external to TM-FPGA 103, as persons of ordinary skill in the art who have the benefit of the description of the invention understand. As an example, communication circuitry 121 may provide various protocol functionality (e.g., Transmission Control Protocol/Internet Protocol (TCP/IP), User Datagram Protocol (UDP) etc.), as desired. As another example, communication circuitry 121 may include network (e.g., Ethernet, token ring, etc.) or bus interface circuitry, as desired.

TM-FPGA 103 may further include one or more memories 124 and one or more controller(s) 127. Memory 124 allows the storage of various data and information (such as user-data, intermediate results, calculation results, etc.) within TM-FPGA 103. Memory 124 may have a granular or block form, as desired. Controller 127 allows interfacing to, and controlling the operation and various functions of circuitry outside the TM-FPGA. For example, controller 127 may constitute a memory controller that interfaces to and controls an external synchronous dynamic random access memory (SDRAM), as desired.

The user invokes a CAD system or software to map a design to the TM-FPGA and implement the design using the TM-FPGA's resources. FIG. 2 depicts various software modules that TM-FPGA CAD software according to illustrative embodiments of the invention uses. The modules include design-entry module 305; synthesis module 310; partition, place, and route module 315; and verification module 320.

Design-entry module 305 allows the integration of multiple design files. The user may generate the design files by using design-entry module 305 or by using a variety of electronic design automation (EDA) or CAD tools (such as industry-standard EDA tools), as desired. The user may enter the design in a graphic format, a waveform-based format, a schematic format, in a text or binary format, or as a combination of those formats, as desired.

Synthesis module 310 accepts the output of design-entry module 305. Based on the user-provided design, synthesis module 310 generates appropriate logic circuitry that realizes the user's design. One or more TM-FPGAs (not shown explicitly) implement the synthesized overall design or system. Synthesis module 310 may also generate any glue logic that allows integration and proper operation and interfacing of various modules in the user's designs. For example, synthesis module 310 provides appropriate hardware so that an output of one block properly interfaces with an input of another block. Synthesis module 310 may provide appropriate hardware so as to meet the specifications of each of the modules in the overall design or system.

Furthermore, synthesis module 310 may include algorithms and routines for optimizing the synthesized design. Through optimization, synthesis module 310 seeks to more efficiently use the resources of the one or more TM-FPGAs that implement the overall design or system. Synthesis module 310 provides its output to partition, place, and route module 315.

Partition and schedule module 312 uses the designer's timing specifications and the known context capacity of the TM-FPGA to create sub-circuits, each of which can be mapped onto the hardware. FPGA partitioning is known to persons of ordinary skill in the art. One may port the partitioning software to TM-FPGAs by making modifications to general FPGA partitioning that fall within the knowledge of persons of ordinary skill in the art who have the benefit of the description of the invention. Generally, the modifications relate to stitching one context to other contexts.

For an ordinary FPGA, any partitioning that satisfies the capacity constraints of the hardware constitutes a proper partitioning. TM-FPGAs entail an additional consideration relating to strictly ordering contexts in sequential order (e.g., from 1 to N for an N-context TM-FPGA). This ordering places a constraint on how the software may achieve partitioning because the outputs of any given partition should be either user signals (such as inputs, outputs, and registers), or should be inputs to future or succeeding contexts (with a larger partition order index).

Although portioning constitutes an NP-complete problem, persons of ordinary skill in the art recognize that the software can find appropriate or approximate solutions (compared to an ideal solution). In practice, the added ordering constraint on the outputs may make finding a solution more difficult compared to ordinary FPGA partitioning, thus perhaps involving longer software running times. As persons of ordinary skill in the art recognize, however, one may convert the added constraint to an additional “cost function” for the partitioning software. Thus, one may use many well-known partitioning algorithms for TM-FPGA partitioning by using cost-function modification. The easiest partitioning algorithm that one may adapt to TM-FPGA is perhaps “partitioning by simulated annealing,” an algorithm well known to persons skilled in the art. The description below provides an example of a general partitioning and scheduling algorithm according to the invention in connection with FIGS. 4-6.

Place and route module 315 is very similar to the place and route modules of ordinary FPGAs. In fact, in one embodiment according to the invention, where each FPGA logic module uses as many context registers as there are contexts, place and route module 315 virtually needs no modification.

In a different embodiment, where the number of such context registers is fewer on average than the number of contexts of the TM-FPGA, one may make modifications to ordinary FPGA place and route algorithms by using “cost functions.” More specifically, similar to the way partition and schedule module 312 introduces additional “cost functions,” the placement may introduce such additional cost functions that measure the mismatch of the number of context registers and the user design's requirements at different locations on the TM-FPGA. This additional cost guides the placement algorithm to a successful eventual placement. As noted above, one may use simulated annealing placement to address this added complexity with minimal modifications to ordinary FPGA place and route. Note, however, that one may use other known FPGA place and route algorithms by making relatively minor modifications, as persons of ordinary skill in the art who have the benefit of the description of the invention appreciate.

By proper use of the TM-FPGA routing resources, place and route module 315 helps to meet the critical timing paths of the overall design or system while simultaneously finding a proper fit to the TM-FPGA's resources. Place and route module 315 optimizes the critical timing paths to help provide timing closure faster in a manner known to persons of ordinary skill in the art with the benefit of the description of the invention. As a result, the overall design or system can achieve faster performance (i.e., operate at a higher clock rate or have higher throughput). The description below in connection with implementing a user's design in a TM-FPGA provides more details of the operation of the place route module 315.

Verification module 320 performs simulation and verification of the design. The simulation and verification seek in part to verify that the design complies with the user's prescribed specifications. The simulation and verification also aim at detecting and correcting any design problems before prototyping the design. Thus, verification module 320 helps the user to reduce the overall cost and time-to-market of the overall design or system.

Verification module 320 may support and perform a variety of verification and simulation options, as desired. The options may include design-rule checking, functional verification, test-bench generation, static timing analysis, timing simulation, hardware/software simulation, in-system verification, board-level timing analysis, signal integrity analysis and electro-magnetic compatibility (EMC); formal netlist verification, and power-consumption estimation, as desired. Note that one may perform other or additional verification techniques as desired and as persons of ordinary skill in the art who have the benefit of the description of the invention understand.

The TM-FPGA CAD software may also include a module (not shown in FIG. 2) or routine for producing a bit-stream for programming or configuring the TM-FPGA, as desired. The module provides a bit-stream that, when used to program the TM-FPGA, causes the TM-FPGA to implement the user's desired circuit or system according to the prescribed specifications or functionality.

The following description provides further details of how a TM-FPGA implements a user's design. Generally, one may represent a synchronous logic circuit as a combination of sequential and combinational logic. FIG. 3 shows a general block diagram representation of a user's circuit for implementation in a TM-FPGA according to the invention. Generally, the circuit may include combinational logic 405 coupled between the user's input(s) and the FPGA registers 408. Similarly, more combinatorial logic 411 may exist between the user's registers and the user's output(s). Parts (or all) of logic 405 and logic 411 may also couple between two or more registers, as signals 414 and 417 indicate.

Note that, generally speaking, logic circuit 411 may receive, and operate on, one or more signals 414 from logic circuit 405 in addition to the signals received from user registers. Likewise, logic circuit 405 may receive, and operate on, one or more signals 417 from logic circuit 411 (i.e., the circuit may include a feedback signal path).

As noted, the CAD software partitions the user's circuit into several sub-circuits, each of which has a sufficiently small size so as to fit entirely within the TM-FPGA's hardware resources. The TM-FPGA operates on each of the sub-circuits during one of its contexts. By partitioning the user's circuit, the CAD software allows the TM-FPGA to implement a larger circuit than a comparable conventional FPGA can realize. Furthermore, because the CAD software performs the partitioning in a transparent manner, the user need not intervene in the partitioning process. Thus, a typical FPGA user can readily use a TM-FPGA according to the invention to implement his or her circuits.

By exploiting the partitioning process, the TM-FPGA attempts to re-use the same hardware during various contexts, hence the time-multiplexed nature of the FPGA. The following description applies to the disclosed multiple-clock TM-FPGAs on a clock-domain basis (i.e., to each of the clock domains that corresponds to one of the multiple clocks). To do so, the TM-FPGA uses an internal clock signal with a frequency that is a multiple of the frequency of the clock signal of the user's circuit. In other words, if the TM-FPGA has N contexts, f _(clk(i),internal) =N·f _(clk(i),user), where f_(clk(i), internal) and f_(clk(i), user) represent the frequencies of the internal clock and of the user's circuit's clock signals for the ith clock domain, respectively. Each cycle of the internal clock corresponds to one of the contexts. N(i) represents the number of contexts used for clk(i), user, and N(i) is less than or equal to N, the maximum number of contexts that the TM-FGPA supports.

On each of the cycles of the internal clock signal, the TP-FPGA operates in one of its contexts (i.e., realizes one part of the partitioned circuit). Each context provides input(s) to one or more future or succeeding contexts, together with any user input, output, and logic signals. In every context (i.e., on every cycle of the internal clock signal), the TM-FPGA generally performs different functions or operations and stores the results of those operations for use in later contexts, as appropriate.

In TM-FPGA, a succeeding context may immediately consume some outputs of a given context, while other outputs hold their state idle for a later context. Note that more than one future or succeeding contexts may use some or all of the outputs. Partition and schedule module 312 (see FIG. 2) seeks to minimize the number of outputs needed in more than one context. As another goal, partition and schedule module 312 also seeks to minimize outputs needed in a context later than the one that immediately follows the current context. Through this minimization, the inventive concepts achieve significant area savings compared to conventional approaches that use as many context registers per programmable logic circuit (e.g., logic element) as the number of contexts of the TM-FPGA.

An ideal partitioning of the user's circuit would result in a circuit that does not include signal inter-dependencies between sub-circuits. FIG. 4 shows an ideally partitioned circuit. Note that such an ideally partitioned circuit is impractical or impossible to realize in relatively large, realistic TM-FPGA designs. In practice, users' circuits almost never lend themselves to the ideal partitioning described above.

FIG. 5 shows a typical partitioning of a user's circuit for implementation in a TM-FPGA according to the invention. Similar to the partitioning in FIG. 4, the partitioning in FIG. 5 includes signals 414 and 417. In addition, it includes signals 420, 423, and 426. The inclusion of signals 420, 423, and 426 represents the complexity of general users' circuits by taking into account signal flows among the logic circuits (405A, 405B), etc.

As noted above, any given context of the TM-FPGA may provide signals to one or more subsequent contexts. To do so, TM-FPGAs according to the invention use context registers or storage elements. FIG. 6 shows an illustrative user's circuit with context registers or storage elements 430 added to facilitate partitioning of the circuit by the CAD software. Put another way, each context may communicate signals and information to another context through the use of context registers 430 (together with the user's input, logic (including registers as part of the user-programmable logic resources of the TM-FPGA), and output signals). Note that the internal clock (with frequency f_(clk(i), internal), described above) serves as the clock source for context registers 430).

As described below in more detail, during the process of mapping the user's circuit to the TM-FPGA's resources, the CAD software attempts to reduce the number of the context registers by merging them with other registers. By doing so, the CAD software reduces the overhead associated with the time-multiplexed nature of the FPGA and, thus, increases overall efficiency of the circuit implementation.

As described above, the context registers facilitate information interchange (temporary results) among the N(i) contexts. Typically, for a given context, say, context j, at least one other context, for example, context (j+1), uses the temporary results of context j. In general, context (j+k) may use the temporary results of context j, where 0<k≦N(i). Note that the case (j+k)>N(i) is permissible, in which case the context with index (j+k) mod N(i) in the next user clock cycle will use the output. Note further that more than one context may use the temporary results from a given context, such as context j. The context registers allow one context to use the temporary results from another context.

As noted above, one may use the following algorithm to implement a relatively compact partitioning and scheduling of a TM-FPGA. The algorithm partitions the entire user's design into N(i) sub-circuits, where N(i) represents the number of the contexts of the TM-FPGA, to be used for clk(i) and N(i)≦N, the maximum number of contexts that the TM-FPGA supports. N(i) will typically be chosen based on the frequency value of clk(i) and the number of context registers used. As one possibility, one may set N(i) to N, and then lower the value on a per-clock-domain basis if the circuit cannot achieve the desired frequency or runs out of context registers. As another possibility, when two user clocks are multiples of each other, one may choose a single common multiple of that frequency to run the time division multiplexing. In this case, one would select N(i) appropriately based on the ratio of f_(clk(i),user) and f_(internal). L represents the number of context registers.

The partitioning occurs such that:

-   (1) Each sub-circuit [j] contains fewer resources (such as LUTs,     registers, etc.) than available in one context; -   (2) Each sub-circuit [j] has O[j] outputs to other partitions, where     O[j]≧0; -   (3) Each sub-circuit [j] has C[j] inputs from previous contexts that     it consumes entirely, where C[j]≧0 (in other words, a future context     no longer needs the inputs from previous contexts); -   (4) No partition [j] may have outputs feeding a partition [i] where     i<j (note, however, that outputs may feed a partition [N+i], where     i<j); and -   (5) The numbers O[j] and I[j] defined in steps (2) and (3) satisfy     the inequality:

$L \geq {\left( {{\sum\limits_{j}{O\lbrack j\rbrack}} - {\sum\limits_{j}{C\lbrack j\rbrack}}} \right).}$ The partitioning and scheduling algorithm achieves its goal by simultaneously minimizing the first sum in step (5) above as well as by maximizing the second sum in step (5).

Note that the circuits in FIGS. 4-6 help to illustrate the inventive partitioning concepts with respect to an exemplary two-context circuit. As persons of ordinary skill in the art who have the benefit of the description of the invention understand, one may apply the disclosed concepts to other circuits, as desired. Such circuits may generally have more than two contexts.

FIGS. 7-FIG. 7 shows a simplified flow diagram of a process that CAD software according to exemplary embodiments of the invention performs to map a user's circuit to a TM-FPGA's resources. Starting with a user's circuit (obtained by the CAD software, as described above), at 503 the software selects a maximum cluster size for each of the clusters. Each of the clusters corresponds to one of the N contexts (i.e., a total of N(i) clusters on a per-clock-domain basis).

At 510, the software partitions the circuit into N(i) clusters for each clock domain, and assigns the clusters to a corresponding context. The software furthermore schedules the contexts. Put another way, it determines the order in which the context follow one another (in time). At 520, the software inserts context registers (described above) into the circuit. The software also assigns each of the context registers to one or more clock cycles, with the clock cycles ranging from zero to (N(i)−1).

At 530, the software checks to determine whether the TM-FPGA includes a sufficient number of context registers to accommodate the user's circuit. The size and amount of hardware resources within the TM-FPGA determines the number of context registers and, hence, the size of the user's circuit that the TM-FPGA can implement.

If the TM-FPGA does not include a sufficient number of context registers, the software concludes at 540 that the TM-FPGA cannot accommodate the user's circuit for the chosen N(i). In that case, one may try a smaller N(i) for that clock domain. Otherwise, at 550, the software performs optimization tasks. More specifically, the software attempts to minimize temporary information and data used in subsequent contexts, and the number of context registers (by merging their functionality with other registers or by re-using them in various contexts).

Note that FIG. 7 shows merely one possible process for mapping a user's circuit to a TM-FPGA's resources. One may make a variety of modifications to the embodiment in FIG. 7, as desired, and as persons of ordinary skill in the art who have the benefit of the disclosed concepts understand. For example, one may perform optimization before checking to determine whether a sufficient number of context registers exist (i.e., reverse the order of 530 and 550). Put another way, one may first perform optimization to reduce the number of context registers before checking to see whether the TM-FPGA's resources include a sufficient number of context registers.

The nature of the information or data stored in the context registers affects the amount of resources that the TM-FPGA uses to implement the user's circuit. Temporary stored data used in the immediately succeeding context use relatively little resources. In that scenario, the software can re-use the context register(s) used to store such data in one or more other contexts.

Temporary stored data used in two or more contexts in the future use more TM-FPGA resources. Here, the data persist for more than one clock cycle. As a result, the software cannot re-use the context register(s) in other contexts.

In some circumstances, a combinational logic circuit in the TM-FPGA may feed an output pin of a user's circuit. An external circuit (i.e., the circuit coupled to the output pin) may expect the logic value at the output pin held constant for an entire cycle of the user's clock signal. In such a case, the software uses a context register to store the logic signal for the output pin and to hold its value for one or more cycles of the user's clock signal. Note that, in the case of signals passing through the TM-FPGA without routing through any sequential logic circuit (e.g., from an input to a combinational logic circuit to an output), the software does not use any time-multiplexing for the programmable logic resources involved in the signal's path (e.g., LUTs).

At 560, the software uses appropriate hardware resources to create N enable signals for routing to appropriate registers for each clock cycle. Note that, for each clock cycle, the software does not enable a context register not needed in the next clock cycle (but needed in subsequent clock cycles).

Subsequently, the software (more specifically, the placement algorithm) assigns the context registers to hardware resources within the TM-FPGA. To do so, the software takes into account not only the location of the resources, but also the clock cycle assignments of the context registers.

FIGS. 8-15 show an example of how one may implement a simple circuit using an TM-FPGA according to the invention. FIG. 8 depicts an example of a simple circuit for implementation in a TM-FPGA. The circuit includes AND gates 603, 606, 609, and 612 (labeled “L1” through “L4,” respectively); OR gate 615 (labeled “L5”); and register 618. The circuit accepts input signals labeled A-L and Z. A clock signal (labeled “CLK”) clocks register 618. Note that the circuit includes a feedback signal path from the Q output of register 618 to an input of AND gate 612.

FIG. 9 shows the circuit of FIG. 8 partitioned by the CAD software into three clusters, cluster 625, cluster 628, and cluster 631. Each of clusters 625, 628, and 631 represents a context (i.e., a three-context TM-FPGA implementation).

The software also assigns the clusters to respective cycles of the internal clock signal. For example, the software may assign the first cluster (cluster 625) to the first cycle of the TM-FPGA internal clock, and so on. The software also schedules the order of the three contexts. As an example, context one becomes active during the first clock cycle, and contexts two and three become active during the two subsequent respective clock cycles.

Note that the CAD software has automatically inserted context registers 640, 643, 646, 649, and 652 (labeled as “R1” through “R5”). The software assigns context registers 640 and 643 to the first clock cycle (context one), context registers 646 and 649 to the second clock cycle (context two), and context register 652 to the third clock cycle (context three).

FIG. 10 illustrates the circuit of FIG. 9, as further processed by the CAD software. More specifically, here, the software merges context register 652 with register 618. Put another way, the software determines that register 652 is redundant because register 618 already ensures that the output of context three is available to context one. Thus, the software merges the functionality of context register 652 with the functionality of register 618 by removing context register 652.

FIG. 11 illustrates the circuit of FIG. 10, as further processed by the CAD software. Here, similar to FIG. 10, the software optimizes the circuit further by re-using context register 649 in more than one context. More specifically, in one context, context register 649 can implement its own functionality, and in another context, it can realize the functionality of register 618. The re-using of context register 649 makes register 618 redundant. Consequently, the software removes register 618 and merges its functionality with the functionality of context register 649.

FIG. 12 shows an illustrative embodiment of a three-context TM-FPGA used to implement the simple circuit shown in FIG. 11. The TM-FPGA includes input/output terminals (or pads) 712; four-input LUTs 703A and 703B; multiplexers (MUXs) 706A, 706B, 709A, and 709B; clock and enable circuit 715; and registers 640, 643, 646, and 649. Each of LUTs 703A-703B may implement the functionality of one of the logic gates (see FIG. 11). Registers 640, 643, 646, and 649 realize, respectively, the functionality of registers R1-R4 (see FIG. 11).

Clock and enable circuit 715 accepts the input clock signal (labeled “CLK”), and generates clock and enable signals for registers 640, 643, 646, and 649. In other words, MUXs 706A, 706B, 709A, and 709B facilitate the routing of the clock and enable signals to registers 640, 643, 646, and 649. Bits in the configuration memory drive the select inputs of MUXs 706A, 706B, 709A, and 709B (configuration memory and connections not shown explicitly for the sake of clarity) so as to enable registers 640, 643, 646, and 649, as appropriate during each context.

FIG. 13 illustrates the functionality realized by the various resources within the TM-FPGA during the first context. Notations inside each of LUTs 703A and 703B denote the functionality of which the LUT implements. For example, LUT 703A implements the functionality of gate L1 (see FIG. 11).

Circles 750 denote an active routing coupling or an active signal. As an example, input A couples to an input of LUT 703A. As another example, MUX 706A and MUX 706B enable, respectively, registers 640 and 643. Similar to FIG. 13, FIG. 14 and FIG. 15 illustrate, respectively, the functionality realized by the various resources within the TM-FPGA during the second and third contexts.

The architecture and structure of TM-FPGAs according to the invention differ in several aspects from conventional FPGAs. The disclosed TM-FPGAs use more configuration memory bits to program a given configurable or programmable element or resource (for example, a programmable logic element or programmable interconnect) than do conventional FPGAs. A conventional FPGA may use a single configuration memory bit to configure or program a resource, say, a programmable interconnect. During the configuration process, configuration circuitry 130 (see FIG. 1) stores an appropriate value in that memory bit in order to configure the programmable interconnect.

In contrast, TM-FPGAs according to the invention use one memory bit or location for each context in order to configure a given resource, for example, the programmable interconnect mentioned above. Each of the memory bits configures the programmable interconnect for a respective context. Thus, for N contexts, the TM-FPGA uses N memory bits per configurable or programmable resource. Note that, for each context, the TM-FPGA may use the configurable or programmable resources differently than other contexts.

In embodiments according to the invention, rather than a single bit of configuration memory, an N-context TM-FPGA uses a circular N-bit first-in, first-out (FIFO) circuit. The configuration data values stored successively in the circular FIFO configure or program the functionality of a given resource within the TM-FPGA. Note that N represents the maximum number of context states allowed. A given design, however, may choose to not use all available contexts or may use different numbers of contexts for different clock domains. As a consequence, the FIFO constitutes a N-bit circular FIFO, programmable to be N or fewer bits.

FIG. 16 shows a block diagram of a configurable or programmable logic circuit (known by various names to persons of ordinary skill in the art, such as LE) used in TM-FPGAs according to exemplary embodiments of the invention. The programmable logic circuit includes four-input LUT 806; CRAM 803; registers 809 and 812; AND gates 815 and 818; and FIFO 821.

Note that FIG. 16 shows a two-context programmable logic circuit, with two registers. One may employ programmable logic circuits suitable for use with other numbers of contexts (generally, N contexts), registers, etc., as desired. Moreover, persons of ordinary skill in the art who have the benefit of the description of the invention understand that FIG. 16 does not explicitly show all components or circuitry within the programmable logic circuit (for example, it omits any input and output MUXs, arithmetic and carry circuits, etc.).

Depending the values of 16 data bits from CRAM 803, LUT 806 can realize an arbitrary logic function of the four inputs, A, B, C, and D. Registers 809 and 812 receive at their D inputs the output signal 830 of LUT 806. The output signals of LUT 806 and registers 809 and 812 constitute the output signals of the programmable logic circuit. Clock signal 835 clocks FIFO 821 and registers 809 and 812.

FIFO 821 helps to generate enable signals for registers 809 and 812. More specifically, in response to clock signal 835, FIFO 821 generates an output signal 840 that it supplies to AND gates 815 and 815. Using signal 840, AND gates 815 and 818 gate ENABLE signal 845 to generate enable signals 850 and 853. Enable signals 850 and 853 drive, respectively, the enable (EN) inputs of registers 809 and 812. By causing appropriate CRAM data values to load into FIFO 821, one may enable register 809 and register 812 in the proper context.

Using FIFO 821 provides an advantage where one desires to include error-correction circuitry. More specifically, adding error-correction circuitry in other memory, circuits used (e.g., SRAM circuitry) tends to be expensive, for example, in terms of circuit complexity, die area, etc. In contrast, adding error-correction capability to FIFO 821 is relatively low-cost. Thus, one may add error-correction circuitry to TM-FPGAs that use FIFOs as described here, with relatively low circuit complexity and a relatively small increase in die area, as desired.

In the example shown in FIG. 16, FIFO 821 constitutes a 2×2-bit circular FIFO circuit. Persons of ordinary skill in the art with the benefit of the description of the invention recognize, however, that the size and configuration of FIFO 821 depends on design and performance specifications for a given application.

FIFO 821 generally has a k×N-bit configuration, where k and N represent the number of registers and the number of contexts, respectively. In the example shown, k=N but, generally, k≦N. As noted, the inventive concepts provide the capability to automatically partition and schedule the user's design, without any input or intervention from the user, into an N-context TM-FPGA, where number of context registers per programmable logic circuit (e.g., logic element) is k on average (but may be more or less than k), and where k<N.

The number of registers per programmable logic circuit need not equal the number of contexts. For example, two registers per programmable logic circuit on average suffice for a four-context TM-FPGA. The average number of registers k per programmable logic circuit may be significantly less than the number of contexts. As an example, three registers may suffice for an eight-context TM-FPGA.

Note that circular FIFOs constitute only one way of configuring resources within the TM-FPGA. As persons of ordinary skill in the art who have the benefit of the description of the invention understand, depending on the application and design and performance specifications and goals, one may user other appropriate circuits, such as a random-access memory (RAM), as desired.

Conventional programmable logic circuits use a single register that multiple contexts can use (for example, a single register, together with N memory bits, for an N-context implementation). In contrast, programmable logic circuits according to the invention (for instance, the two-context version in FIG. 16) use multiple registers. The programmable logic circuits therefore need not include the memory circuits associated with the conventional single-register approach and may instead use the FIFO structure (or other desired structure). Note that different programmable logic circuits in TM-FPGAs according to the invention need not include the same number of registers.

Furthermore, the number of registers per programmable logic circuit need not equal the number of contexts. For example, two registers suffice for a four-context TM-FPGA. The average number of registers per programmable logic circuit may be less than the number of contexts. In fact, depending on the extent of partitioning, placing, and routing efficiencies and optimization involved, the average number of registers may be significantly less than the number of contexts. As an example, three registers may suffice for an eight-context TM-FPGA.

As noted above, the disclosed TM-FPGAs can provide area efficiencies compared to conventional approaches. Consider an N-context TM-FPGA, with f context registers. Assume that the TM-FPGA uses relatively simple context registers (no synchronous load, clear, reset, etc.). Assume further that each of the context registers uses about 2% of the TM-FPGA's core area. Using those assumptions, one may express the cost area, C, of the TM-FPGA as:

$C = {\left( {\frac{N}{3} + \frac{2}{3} + {f \cdot \frac{1}{48}}} \right).}$

In the above formula, the fractions 1/48 and N/3 represent respectively the approximate contribution of the flip-flop area (about 2%) and the area taken up by configuration bits. The estimate is approximate, based on the empirical observation that control bits take up approximately one third of the area of an SRAM-based FPGA. The actual value varies slightly from one process technology to another, as well as from one implementation to another. As a result, one may express the die area ratio, R, between the TM-FPGA and a conventional FPGA as:

$R = {\frac{\left( {\frac{N}{3} + \frac{2}{3} + \frac{f}{48}} \right)}{N}.}$

Accordingly, one may express the area efficiency, E, as:

$E = {\frac{3}{\left( {1 + \frac{2}{N} + \frac{f}{16\; N}} \right)}.}$ Table 1 below expresses the efficiency, E, for various values of N and f:

TABLE 1 N ƒ E  1 0 1.00  2 1 1.48  4 2 1.96  6 3 2.20  8 3 2.36 16 4 2.63 ∞ log₂(∞) 3.00

Another aspect of the inventive concepts relates to apparatus and methods for multiple-clock TM-FPGAs. The inventive concepts disclosed here contemplate multiple-clock TM-FPGAs in which one or more signals make a transition between clock domains. The source clock domain and the destination clock domain may each constitute a desired clock domain, such as a clock domain within the TM-FPGA or a clock domain external to the TM-FPGA. The multiple-clock aspects assume a steady input clock (e.g., not stopped while the TM-FPGA is operating), with a relatively stable, known frequency.

With the disclosed multiple-clock TM-FPGAs, design flow, and CAD methodology, the user does not have to intervene in the design process as is the case with conventional TM-FPGAs. Put another way, the multiple-clock nature and operation of the TM-FPGAs is transparent to the user. Thus, the disclosed multiple-clock TM-FPGAs have the advantage that they use and handle multiple clocks and yet appear as a traditional FPGA to the user.

Note that the above description of inventive concepts relating to multiple-context TM-FPGAs applies to the multiple-clock TM-FPGAs on a clock-domain by clock-domain basis, as persons of ordinary skill in the art who have the benefit of the description of the invention understand. In the multiple-clock TM-FPGAs, one performs the partitioning (by using the TM-FPGA CAD tools described above) on a clock-domain by clock-domain basis.

According to one feature of the invention described below, the multiple clocks may be related to one another (for example, they may have frequencies that are multiples of a given frequency). According to another feature of the invention described below, the multiple clocks may be unrelated to one another. In either case, the multiple-clock TM-FPGAs provide a mechanism for the transition of signal(s) between the clock domains.

FIG. 17 shows a multiple-clock TM-FPGA 103 according to an illustrative embodiment of the invention. In the embodiment shown, TM-FPGA 103 includes clock domain 1003 and clock domain 1006. Clock domain 1003 uses clock signal 1015 (labeled as CLK1), whereas clock domain 1006 uses clock signal 1018 (labeled as CLK2). As noted above, generally, clock signal 1015 and clock signal 1018 may be related or unrelated.

Clock domain 1003 may include a number of circuit elements or cells that clock signal 1015 drives. For example, clock domain 1003 may include register (or flip-flop) 1009. Clock signal 1015 drives the clock input of register 1009. Similarly, clock domain 1006 may include a number of circuit elements or cells that clock signal 1018 drives. As one example, in FIG. 17, clock domain 1006 includes register (or flip-flop) 1012. Clock signal 1018 drives the clock input of register 1012.

The Q output of register 1009, which resides in clock domain 1003, drives the data (D) input of register 1012. In clock domain 1006, the data input of register 1012 receives the output signal of register 1009. Thus, the output signal of register 1009 crosses the boundaries of clock domain 1003 and travels to clock domain 1006.

Note that, although the embodiment in FIG. 17 shows TM-FPGA 103 with two clock domains, the inventive concepts generally contemplate TM-FPGAs with a desired number of clock domains (i.e., two or higher). One may extend the concepts disclosed with respect to FIG. 17 to TM-FPGAs with other numbers of clock domains, as desired, and as persons of ordinary skill in the art who have the benefit of the description of the invention understand. Furthermore, as noted above, in the general case, the clock signals may be related or unrelated, as desired.

FIG. 18 illustrates an example of related multiple clock signals in a TM-FPGA according to an exemplary embodiment of the invention. FIG. 18 includes two signal waveforms 1015A and 1018A. Signal waveform 1015 corresponds to clock signal 1015, whereas signal waveform 1018A represents clock signal 1018. (Recall from the description of FIG. 17 that clock signal 1015 and clock signal 1018 provide clock signals to register 1009 and register 1012, respectively.)

Signal waveform 1015A has a period shown as T₁, and signal waveform 1018A has a period denoted as T₂. In general, clock signal 1015 may have a phase shift, denoted as t_(ps) in FIG. 18, from clock signal 1018. Because clock signal 1015 has a defined relationship to clock signal 1018, the period T₁ relates to the period T₂.

In order to facilitate proper signal transfers in a multiple-clock environment, any electronic circuit should meet certain intrinsic timing constraints. By creating a TM-FPGA that can meet those constraints, one can create an architecture that will intrinsically work the same as a traditional FPGA fro the user's viewpoint. An example helps to illustrate those concepts. Suppose that clock signals 1015 and 1018 have the following frequencies: f ₁=50 MHz, and f ₂=100 MHz. In other words, the clock signals have the following periods: T ₁=20 ns, and T ₂=10 ns. Further assume that the time shift or phase shift (t_(ps)) has a value of 6 ns: t _(ps)=6 ns, and that register 1012 (see FIG. 17) has setup (t_(su)) and hold (t_(h)) times, respectively, of: t _(su)=1 ns, and t _(h)=1 ns.

In order for the transfer of data to occur properly from register 1009 to register 1012 on the two rising edges that immediately follow the rising edge of clock signal 1015, data propagation from register 1009 to register 1012 should begin to occur no later than a period, say, t₁. Generally, t₁ should meet the following condition in order for the transfer to take place properly: t ₁≦(t _(ps) −t _(su)). Using the values for t_(ps) and t_(su) from the above example, one obtains t₁≦5 ns.

Furthermore, the data should remain present (i.e., stay constant or hold their values) until at least at a time, say, t₂, in order to meet the hold time of register 1012 on the second edge of clock signal 1018. Generally, t₂ should meet the following condition: t ₂≧(T ₂ +t _(ps) +t). Using the values for T₂, t_(ps), and t_(h) from the above example, one obtains t₂≧17 ns. Note, however, that the transfer should complete before the arrival of the next cycle of clock 1015. In other words, generally: t ₂ <t _(ps) −t _(su)+2T ₂. Using the values for t_(ps), t_(su), and T₂ from the above example, one obtains t₂<25 ns. Thus, the various time periods associated with the clock signals and the register transfer times place a lower limit on how slowly the transfer of data may occur.

Note that, in the general case, a lower limit may also exist on the speed of the data transfer. More specifically, suppose that in the example above, the data transfer cannot happen within the t₁≦5 ns period described above. One may, however, meet that condition during the following cycle of clock signal 1018 by meeting the following conditions (note that a similar situation might occur for a negative phase shift, i.e., t_(ps)<0): t ₁ ≦t _(ps) −t _(su) +T ₂; t ₂ ≧t _(ps) −t _(h) +T ₂; t ₂ <t _(ps) t _(su)+3T ₂; and t ₁ ≧t _(ps) +t _(h). Note that the last condition constitutes the second condition applied to the previous edge of clock signal 1018. Provided that the TM-FGPA meets those constraints, it will satisfy the inter-clock-domain data transfer requirements. Note that because the majority of the delay happens deterministically from the context registers, the conditions are easier to meet than a traditional FPGA because of being less subject to minimum timing analysis. Note that all propagation delays are a function of T₂ rather T₁ because the time periods relate to meeting the setup and hold constraints of the destination register (e.g., register 1012 in FIG. 18).

Thus, the various time periods associated with the clock signals (including the phase shift, if any) and the register transfer times (including the setup and hold times) overall place bounds and conditions on when various events should occur in order for the transfer to take place properly and reliably. To provide a reliable, proper transfer of data, TM-FPGAs according to the invention meet those conditions.

More specifically, to help meet the conditions, TM-FPGAs according to the invention use one or more of the following features. First, the TM-FPGAs represent the multiple clock domains (e.g., clock domain 1003 and clock domain 1006 in the above example) in their clocking structure and circuitry.

In the absence of a phase shift (t_(ps)=0), one may simply run an internal clock at a frequency (f_(clk, internal)) that is a common multiple of the base clock frequencies (i.e., the frequencies of the multiple clock domains corresponding to the user's clock signals). In other words, if a user clock signals exist, then f _(clk,internal)=β, where β represents a common multiple of the α user clock signals. Note that, as described above, TM-FPGAs according to the invention may include multiple internal clock signals, one per clock domain. One may apply the above methodology to each of the internal clock signals, as desired.

Conversely, if a phase shift exists (t_(ps)≠0), then one may use a single internal clock (f_(clk, internal)), provided that the internal clock represents the phase shift properly. For example, suppose that a user clock has a frequency f₁=10 MHz and the internal clock has a frequency f_(clk, internal)=100 MHz. One may readily represent a phase shift on the user clock of any multiple of 10 ns (e.g., 10 ns, 20 ns, etc.).

In addition, one may set f_(clk, internal) to a multiple of 100 MHz such as 200 MHz or 300 MHz, which would result in a 5 ns phase shift or a 3.3 ns phase shift, respectively. One may also route multiple clocks, potentially from a single phase-locked loop (PLL) circuit with multiple phase shift taps to achieve the desired phase shift, or route the output of a single PLL to the FPGA's circuitry and use a programmable delay element in the programmable logic, with a desired level of granularity. The delay of the delay element does not have to equal the entire phase shift, but instead just has to provide an appropriate delay, taking into account the characteristics of the internal signal. For example, if f_(clk, internal) has a 200 MHz frequency (i.e., 5 ns period) and one wishes to realize a 7 ns phase shift, one may use a delay element to provide a 2 ns delay (the sum of the clock period and the delay equals 7 ns, the desired phase shift).

As an alternative, one may use multiple internal (or accelerated) clock signals to represent the multiple clock domains within the user's design or system. To do so, one may either provide for the selection of a clock signal for each register from a set of internal clock signals, or by segregating the TM-FPGA into multiple clock domains, each with its own internal clock signal.

Second, the data and signal transfers should occur within the allocated time periods. This condition may result in some logic signal propagations to occur in fewer or more cycles of the internal clock signal than would be the case conventionally. Third, the final register using an internal clock signal that holds the data to be transferred should hold the data for the specified amount of time. This condition may result in the register's unavailability for multiple uses (use as a context register in multiple context) because it holds the data for the entire amount of time that ensures proper transfer to the data's destination.

As noted above, clock signal 1015 and clock signal 1018 (see FIG. 17) may be unrelated to one another. In the case of unrelated clock signals, data transfer takes place between multiple clock domains with unknown relationships to one another. As an example, one may wish to transfer data from a clock domain with a clock frequency of 50 MHz to another clock domain with a clock frequency of 66 MHz.

Note that the multiple clock domains may even have the same respective frequencies. For example, one may seek to transfer data from a clock domain with a clock frequency of 50 MHz to another clock domain with a frequency of 50 MHz. The two 50 MHz clock domains, however, may have an unknown phase relationship to each other, or a phase relationship known to the designer, but not specified or input by the designer to the TM-FPGA CAD software.

In order to accommodate multiple unrelated clock domains, some embodiments of the inventive TM-FPGAs use FIFOs. The FIFO in illustrative embodiments may constitute a dual-port RAM, although one may use other circuitry, as persons of ordinary skill in the art who have the benefit of the description of the invention understand. The FIFO includes logic circuitry that keeps track of the status of the FIFO, i.e., whether it is full, empty, or neither full or empty.

Given multiple clock signals corresponding to multiple clock domains, a first clock signal may add or write data to the FIFO as long as the FIFO is not full. Conversely, a second clock signal may remove or read data from the FIFO as long as the FIFO is not empty. In this manner, the FIFO essentially allows asynchronous transfer of data between the clock domains corresponding to the first and second clock signals. Note that in such a scheme, a clock signal should have the capability to write or add data to the FIFO from registers clocked by an internal (accelerated) clock signal. Note also that the FIFO receives its input from circuitry within one clock domain and provides it output to circuitry in a second clock domain. Accordingly, the input and output from the FIFO follows the above conditions on transferring to a register within a single clock domain. Thus, with the use of a FIFO, the multiple clock TM-FPGA will behave in a manner identical to a traditional FPGA, and the use of time multiplexing will be transparent to the user.

Other embodiments of TM-FPGAs according to the invention do not use FIFOs to accommodate multiple unrelated clock domains with their corresponding clock signals. Generally speaking, in this situation, the frequencies of the respective clock signals may either constitute multiples of one another or they may not.

FIG. 19 shows an example of two clock signals 1015A and 1018A where the frequency of one clock signal does not constitute a multiple of the frequency of the other clock signal. Conversely, FIG. 20 illustrates an example of two clock signals 1015A and 1018A where the frequency of one clock signal constitutes a multiple of the frequency of the other clock signal. More particularly, clock signal 1018A has twice the frequency of clock signal 1015A.

In the case where the clock frequencies are not multiples of one another (e.g., FIG. 19), the phase relationship among the clock signals presumably is time-varying (i.e., it changes as a function of time). Thus, no guarantee exists regarding the arrival time of data with respect to edges of clock signals. Furthermore, no assurance exists that data arrival times would not violate register setup and hold times, thus causing meta-stability. Although some of these problems are inherent in a multi-clock environment, even with a conventional FPGA, one can make the TM-FPGA behave as consistently as a conventional FPGA would, thus achieving the goal of transparency regarding the use of a TM-FPGA. To achieve that goal, the TM-FPGA should have a maximum propagation delay from the source register to a destination register (e.g., register 1009 and register 1012, respectively, in FIG. 17) equal to the corresponding time in a non-time-multiplexed FPGA. Furthermore, the final register using an internal clock to propagate data from the source register to the destination register should hold the data constant for an entire cycle of the clock signal corresponding to the source register. One may do so by making appropriate use of the context registers to create the needed delay as measured by the internal clock, and by appropriately using the CE input of the final context register before the user-destination register to hold the data for the desired time-period.

Alternatively, the clock frequencies may constitute multiples of one another (e.g., FIG. 20), or perhaps the clock frequencies are equal, but with a constant unknown phase relationship (i.e., unknown t_(ps)). This situation is similar to the case where the frequencies of the clock signals are not multiples of one another, described above, with the exception that this case works in a traditional FPGA even though the CAD software does not have enough information to know that it will work. In this case, as long as one meets the conditions mentioned in the preceding paragraph, the TM-FPGA works in the same cases as a traditional FPGA would.

As with the case above, in this case, no guarantee exists regarding the arrival time of data with respect to edges of clock signals or that data arrival times would not violate register setup and hold times. Similar to the case described above, the TM-FPGA should have a maximum propagation delay from the source register to a destination register (e.g., register 1009 and register 1012, respectively, in FIG. 17) equal to the corresponding time in a non-time-multiplexed FPGA. Also, the final register using an internal clock to propagate data from the source register to the destination register should hold the data constant for an entire cycle of the clock signal corresponding to the source register. As long as the propagation delay (including the time taken in the context registers and the delay from the final context register to the destination register, is the same as in a traditional FPGA or meets a user's specifications), whether a circuit provides signal transfer reliably does not depend on whether one uses a traditional FPGA or a TM-FPGA. Consequently, the use of time multiplexing is transparent to the user.

As described above, several conditions should hold in order for TM-FPGAs to accommodate multiple clock domains with corresponding multiple clock signals. In TM-FPGAs according to the invention, the CAD software (described above, for example in connection with FIG. 2) allows the use of multiple clock domains in a transparent manner, such that the user need not intervene in the process of implementing the user's circuit or design.

Thus, a typical FPGA user can readily use a TM-FPGA according to the invention to implement his or her circuits without intervening in the process of mapping the circuit to the TM-FPGA's resources, including the multiple clock domains. In other words, the user describes the circuit to the CAD software, and the software synthesizes the circuit, partitions and schedules, places and routes the various resources, and verifies the circuit transparently, without intervention by the user.

Note that the descriptions of the illustrative embodiments above pertain to two clock signals. As persons of ordinary skill in the art who have the benefit of the description of the invention understand, however, one may extend the disclosed concepts to more than two clocks, as desired. The extension of the inventive concepts to more than two clock signals entails modifications that fall within the knowledge of persons of ordinary skill in the art who have the benefit of the description of the invention.

Another aspect of the inventive concepts relates to improved data transfer to a destination external to the TM-FPGA. FIG. 21 shows a circuit arrangement in which TM-FPGA 103 according to an illustrative embodiment of the invention delivers data to an external destination. Generally, the circuit arrangement in FIG. 21 is similar to the circuitry in FIG. 17, except that clock domain 1006 resides outside TM-FPGA 103.

More particularly, in FIG. 21, TM-FPGA 103 includes clock domain 1003. Circuitry within clock domain 1003 drives a circuit in an external clock domain 1006. Clock domain 1003 uses clock signal 1015 (labeled as CLK1), whereas clock domain 1006 uses clock signal 1018 (labeled as CLK2).

Clock domain 1003 may include a number of circuit elements or cells that clock signal 1015 drives. For example, clock domain 1003 may include register (or flip-flop) 1009. Clock signal 1015 drives the clock input of register 1009. Similarly, clock domain 1006 may include a number of circuit elements or cells that clock signal 1018 drives. As one example, FIG. 21 shows clock domain 1006 as including register (or flip-flop) 1012. Clock signal 1018 drives the clock input of register 1012.

The Q output of register 1009, which resides in clock domain 1003, drives the data (D) input of register 1012. In clock domain 1006, the data input of register 1012 receives the output signal of register 1009. Thus, the output signal of register 1009 crosses the boundaries of clock domain 1003 and travels to clock domain 1006 (external to TM-FPGA 103).

Generally speaking, clock domain 1006 may possess unknown characteristics with respect to clock domain 1003. In other words, clock signal 1015 may bear no relationship to clock signal 1018, or may have a relationship of which the user has knowledge but of which has not informed the CAD software. Thus, TM-FPGA 103 generally cannot control events within clock domain 1006 (e.g., how quickly or when data store within register 1012), but it can ensure data transfer within a specified time, T_(co), after the application of clock signal 1015.

More specifically, in TM-FPGAs according to the inventive concepts, data travel from TM-FPGA 103 to the destination within the specified time period T_(co), although the data do not become available before a minimum T_(co) (T_(co, min)) has transpired. Furthermore, TM-FPGA 103 holds the data constant for an entire cycle of clock signal 1015 (or more than one cycle, as desired). During this time period, circuitry within clock domain 1006 may sample and store the data, as desired.

In practice, timing parameters (e.g., T_(co, min)) of TM-FPGAs depend on various parameters, such as process, voltage, and temperature (PVT). To ensure that the data do not become available sooner than the minimum T_(co) (T_(co, min)), TM-FPGA 103 uses the internal clock signal, rather than clock signal 1015, to delay the data and meet the specified minimum T_(co) (T_(co, min)).

As described above, the internal clock signal has a frequency (f_(clk, internal)) that is a multiple of the frequency of the clock signal of the user's circuit (e.g., clock signal 1015). Using the internal clock provides more granularity and, hence, more precision in the delay before the data become available (i.e., T_(co, min)). In other words, TM-FPGA 103 makes the data available after a specified number of cycles of the internal clock have transpired. As a result, the minimum T_(co) (T_(co, min)) becomes relatively independent of PVT. In a traditional FPGA, the entire signal propagation delay is subject to PVT variation. In the disclosed TM-FPGAs, only the propagation delay from the final context register to the output is subject to PVT. Because that propagation delay represents a small portion of the overall path delay, the variation because of PVT decreases.

As noted above, the TM-FPGA holds the data constant for an entire cycle of clock signal 1015 (or more than one cycle, as desired), rather than the internal clock signal. By using clock signal 1015 and by using register 1009 instead of potentially providing data from a general logic circuit, TM-FPGA 103 tends to reduce or eliminate glitches at the Q output of register 1009 (or at output pin 1103 of TM-FPGA 103). Note that, in some situations, the user may seek to use such glitches to generate a pulse. Under those circumstances, one may readily synthesize the desired pulse by using the internal clock signal.

Another aspect of the inventive concepts relates to clock architectures for TM-FPGAs. Generally, the presence of the multiple clock domains within TM-FPGAs according to various embodiments of the invention makes desirable the availability of flexible clock networks or architectures. One may use one or more of the clocking schemes and related networks and architectures described below.

FIG. 22 shows a circuit arrangement for providing multiple clock signals in TM-FPGA 103 according to an exemplary embodiment of the invention. The circuit arrangement includes clock generator 1203 and a plurality of registers 1209A-1209C. Clock generator 1203 receives one or more signals 1212 and, in response, generates multiple clock signals. Signal(s) 1212 may represent user clock signals, e.g., user clock signals 1-n. In the arrangement shown, clock generator 1203 generates multiple clock signals 1206 (labeled individually as CLK₁, CLK₂, . . . , CLK_(n)).

Each of registers 1209A-1209C may use a clock signal independent of the other registers. For example, register 1209A may use clock signal CLK₁, whereas register 1209B may use clock signal CLK₂, and so on. In other words, using the multiple clock signals 1206, one may clock registers 1209A-1209C independently of one another. (Of course, as persons of ordinary skill in the art who have the benefit of the description of the invention understand, one may use a given clock signal to clock more than one register, as desired.)

Each of registers 1209A-1209C may have a clock enable (CE) input. The clock enable input allows the clocking of each of registers 1209A-1209C independently of one another. As an example, at a given moment in time, register 1209A may receive a clock enable signal, but register 1209C may not. The combination of multiple clock signals 1206 and the register clock enable inputs allows a flexible clock arrangement for TM-FPGA 103.

FIG. 23 illustrates another circuit arrangement for providing multiple clock signals in TM-FPGA 103 according to an exemplary embodiment of the invention. The circuit arrangement includes a plurality of clock generators 1260A-1260C. Clock generators 1260A-1260C provide a plurality of non-overlapping clock signals, labeled CLK₁, CLK₂, . . . , CLK_(n), respectively. For example, clock generator 1260A generates clock signal CLK₁, clock generator 1260B generates clock signal CLK₂, and so on.

The plurality of clock generators 1260A-1260C correspond to a plurality of clock regions or domains 1253A-1253C. More specifically, each clock generator in the plurality of clock generators 1260A-1260C corresponds to a clock domain in the plurality of clock domains 1253A-1253C. For example, clock generator 1260A corresponds to clock signal CLK₁, and the like.

The number of clock generators 1260A-1260C (and, hence, the number of clock signals) in a particular implementation may depend on a number of design and performance considerations, as persons of ordinary skill in the art who have the benefit of the description of the invention understand. For example, one may use four clock generators, where each clock generator provides a corresponding clock signal to a region of TM-FPGA 103, such as a corresponding quadrant. Generally, the TM-FPGA's CAD software (see FIG. 2 and associated description) places circuitry associated with each clock signal in an appropriate physical location. As an example, with a four-quadrant TM-FPGA and four corresponding clock signals, the CAD software places (and routes accordingly) in a corresponding quadrant the circuitry that each of the clock signals drives.

Note that, rather than providing non-overlapping clock signals, the circuit arrangement in FIG. 23 may provide overlapping clock signals, as desired. More specifically, in this scenario, clock generators 1260A-1260C provide a plurality of overlapping clock signals, CLK₁, CLK₂, . . . , CLK_(n), respectively. Each clock generator in the plurality of clock generators 1260A-1260C may correspond to a clock domain in the plurality of clock domains 1253A-1253C.

With respect to the multiple clock domains, one may optionally provide the capability of combining or tying together two or more of the clock domains. To do so, one may couple to one another the desired clock domains. As an alternative, one may use a PLL circuit, and either drive each clock region from an output of the PLL, or use the PLL together with a desired number of clock generators.

FIG. 24 depicts a circuit arrangement for the latter option (i.e., a PLL driving a number of clock generators). The circuit arrangement includes PLL 1303, and a plurality of clock generators 1260A-1260C. Output signal 1306 of PLL 1303 drives the plurality of clock generators 1260A-1260C. Clock generators 1260A-1260C provide a plurality of non-overlapping clock signals, labeled CLK₁, CLK₂, . . . , CLK_(n), respectively. For example, clock generator 1260A generates clock signal CLK₁, clock generator 1260B generates clock signal CLK₂, and so on.

The plurality of clock generators 1260A-1260C correspond to a plurality of clock regions or domains 1253A-1253C. More specifically, each clock generator in the plurality of clock generators 1260A-1260C corresponds to a clock domain in the plurality of clock domains 1253A-1253C. For example, clock generator 1260A corresponds to clock signal CLK₁, and the like. As with non-overlapping clock domains, in the case of combined or tied clock domains, the CAD software can still place and route appropriately the circuitry corresponding to each clock domain.

Generally, note that one may apply the inventive concepts effectively to various programmable logic circuitry or ICs known by other names in the art, as desired, and as persons skilled in the art with the benefit of the description of the invention understand. Such circuitry include devices known as programmable logic device (PLD), complex programmable logic device (CPLD), and programmable gate array (PGA).

Referring to the figures, persons of ordinary skill in the art will note that the various blocks shown may depict mainly the conceptual functions and signal flow. The actual circuit implementation may or may not contain separately identifiable hardware for the various functional blocks and may or may not use the particular circuitry shown.

For example, one may combine the functionality of various blocks into one circuit block, as desired. Furthermore, one may realize the functionality of a single block in several circuit blocks, as desired. The choice of circuit implementation depends on various factors, such as particular design and performance specifications for a given implementation, as persons of ordinary skill in the art who have the benefit of the description of the invention understand.

Other modifications and alternative embodiments of the invention in addition to those described here will be apparent to persons of ordinary skill in the art who have the benefit of the description of the invention. Accordingly, this description teaches those skilled in the art the manner of carrying out the invention and is to be construed as illustrative only.

The forms of the invention shown and described should be taken as the presently preferred or illustrative embodiments. Persons skilled in the art may make various changes in the shape, size and arrangement of parts without departing from the scope of the invention described in this document. For example, persons skilled in the art may substitute equivalent elements for the elements illustrated and described here.

Moreover, persons skilled in the art who have the benefit of this description of the invention may use certain features of the invention independently of the use of other features, without departing from the scope of the invention. 

1. A multiple-clock time-multiplexed field programmable gate array (TM-FPGA), comprising: a plurality of clock signals coupled to programmable logic circuitry; wherein a user's circuit can be mapped to the programmable logic circuitry without the user's intervention in mapping the circuit to the programmable logic circuitry, wherein at least two clock signals of the plurality of clock signals are related, and wherein the two clock signals are phase shifted from each other.
 2. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 1, wherein the programmable logic circuitry comprises a plurality of registers, and wherein each clock signal in the plurality of clock signals couples to a respective register in the plurality of registers.
 3. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 2, wherein first and second clock signals in the plurality of clock signals couple to respective first and second registers in the plurality of registers, and wherein the first register provides data to the second register.
 4. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 3, wherein the data transfer from the first register to the second register begins to occur in a time period no greater than a difference between a time period corresponding to a phase shift between the first and second clock signals and a setup time of the second register.
 5. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 4, wherein the data remain present for at least a time period equal to the sum of a period of the second clock signal, the time period corresponding to the phase shift between the first and second clock signals, and a hold time of the second register.
 6. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 5, wherein the data transfer completes in a time period less than the sum of the phase shift between the first and second clock signals, and a hold time of the second register, minus the setup time of the second register, plus twice the period of the second clock signal.
 7. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 2, further comprising, for each clock domain, an internal clock signal with a frequency that is a common multiple of the respective frequencies of the plurality of clock signals.
 8. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 2, wherein each clock signal in the plurality of clock signals corresponds to a respective clock domain of the time-multiplexed field programmable gate array (TM-FPGA).
 9. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 2, wherein the plurality of clock signals are unrelated to one another.
 10. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 9, wherein, first and second clock signals in the plurality of clock signals couple to respective first and second registers in the plurality of registers, and wherein the first register provides data to the second register through a first-in, first-out (FIFO) circuit.
 11. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 2, further comprising a plurality of clock generators, wherein each clock generator in the plurality of clock generators provides a respective clock signal in the plurality of clock signals.
 12. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 11, further comprising a phase-locked loop (PLL) circuit configured to provide an output signal to the plurality of clock generators.
 13. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 2, further comprising a clock generator configured to provide the plurality of clock signals.
 14. A multiple-clock time-multiplexed field programmable gate array (TM-FPGA), comprising programmable logic circuitry clocked by a plurality of clock signals, wherein a user's circuit is automatically mapped to the programmable logic circuitry, wherein at least two clock signals of the plurality of clock signals are related, and wherein the two clock signals are phase shifted from each other.
 15. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 14, wherein at least two clock signals of the plurality of clock signals are unrelated.
 16. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 14, wherein the programmable logic circuitry couples to a circuit external to the multiple-clock time-multiplexed field programmable gate array (TM-FPGA), wherein the circuit receives data from the programmable logic circuitry.
 17. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 16, wherein the data are transferred to a circuit external to the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) within a specified number of cycles of an internal clock signal of the multiple-clock time-multiplexed field programmable gate array (TM-FPGA).
 18. The multiple-clock time-multiplexed field programmable gate array (TM-FPGA) according to claim 17, wherein the internal clock signal has a frequency that is a multiple of a frequency of the first clock signal.
 19. A method of implementing an electronic circuit using a multiple-clock time-multiplexed field programmable gate array (TM-FPGA), the method comprising: obtaining a design of the electronic circuit design from a user; mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) without the user's intervention; and programming the multiple-clock time-multiplexed field programmable gate array (TM-FPGA), wherein at least two clock signals in a plurality of clock signals in the time-multiplexed field programmable gate array (TM-FPGA) are related, and wherein the two clock signals are phase shifted from each other.
 20. The method according to claim 19, wherein mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) further comprises routing each clock signal in a plurality of clock signals within the time-multiplexed field programmable gate array (TM-FPGA) to a respective register in the plurality of registers in the time-multiplexed field programmable gate array (TM-FPGA).
 21. The method according to claim 20, further comprising: routing first and clock signals in the plurality of clock signals to respective first and second registers in the plurality of registers; and routing an output of the first register to an input of the second register, wherein the first register transfers data to the second register.
 22. The method according to claim 21, wherein mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) further comprises performing the mapping such that data transfer from the output of first register to the input second register begins to occur in a time period no greater than a difference between a time period corresponding to a phase shift between the first and second clock signals and a setup time of the second register.
 23. The method according to claim 22, wherein mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) further comprises performing the mapping such that the data remain present for at least a time period equal to the sum of a period of the second clock signal, the time period corresponding to the phase shift between the first and second clock signals, and a hold time of the second register.
 24. The method according to claim 23, wherein mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) further comprises performing the mapping such that the data transfer completes in a time period less than the sum of the phase shift between the first and second clock signals, and a hold time of the second register, minus the setup time of the second register, plus twice the period of the second clock signal.
 25. The method according to claim 20, wherein an internal clock of the time-multiplexed field programmable gate array (TM-FPGA) has a frequency that is a common multiple of the respective frequencies of the plurality of clock signals.
 26. The method according to claim 20, wherein mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) further comprises mapping each clock signal in the plurality of clock signals corresponds to a respective clock domain of the time-multiplexed field programmable gate array (TM-FPGA).
 27. The method according to claim 20, wherein the plurality of clock signals are unrelated to one another.
 28. The method according to claim 27, wherein mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) further comprises: driving first and second registers in the plurality of registers by first and clock signals in the plurality of clock signals; and routing data from the first register to the second register through a first-in, first-out (FIFO) circuit.
 29. The method according to claim 20, wherein mapping the electronic circuit to resources within the multiple-clock time-multiplexed field programmable gate array (TM-FPGA) further comprises providing a plurality of clock generators configured to generate the plurality of clock signals.
 30. The method according to claim 29, further comprises providing a phase-locked loop (PLL) circuit configured to provide an output signal to the plurality of clock generators.
 31. The method according to claim 30, further comprising providing a clock generator configured to provide the plurality of clock signals. 